Spot-On
spot-on-neighbor.h
1 /*
2 ** Copyright (c) 2011 - 10^10^10, Alexis Megas.
3 ** All rights reserved.
4 **
5 ** Redistribution and use in source and binary forms, with or without
6 ** modification, are permitted provided that the following conditions
7 ** are met:
8 ** 1. Redistributions of source code must retain the above copyright
9 ** notice, this list of conditions and the following disclaimer.
10 ** 2. Redistributions in binary form must reproduce the above copyright
11 ** notice, this list of conditions and the following disclaimer in the
12 ** documentation and/or other materials provided with the distribution.
13 ** 3. The name of the author may not be used to endorse or promote products
14 ** derived from Spot-On without specific prior written permission.
15 **
16 ** SPOT-ON IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 ** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 ** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 ** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 ** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 ** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 ** SPOT-ON, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27 
28 #ifndef _spoton_neighbor_h_
29 #define _spoton_neighbor_h_
30 
31 #include <QAtomicInt>
32 #if QT_VERSION >= 0x050501 && defined(SPOTON_BLUETOOTH_ENABLED)
33 #include <qbluetoothsocket.h>
34 #endif
35 #include <QDateTime>
36 #if (QT_VERSION >= QT_VERSION_CHECK(5, 12, 0))
37 #include <QDtls>
38 #endif
39 #include <QFuture>
40 #include <QHostAddress>
41 #include <QHostInfo>
42 #include <QMap>
43 #include <QNetworkProxy>
44 #include <QPointer>
45 #include <QReadWriteLock>
46 #include <QSqlDatabase>
47 #include <QSslSocket>
48 #include <QThread>
49 #include <QTimer>
50 #include <QUdpSocket>
51 #include <QUuid>
52 
53 #include "Common/spot-on-common.h"
54 #include "Common/spot-on-crypt.h"
55 #include "Common/spot-on-external-address.h"
56 #include "Common/spot-on-misc.h"
57 #include "Common/spot-on-send.h"
58 #include "Common/spot-on-socket-options.h"
59 #include "spot-on-sctp-socket.h"
60 
61 class spoton_neighbor_tcp_socket: public QSslSocket
62 {
63  Q_OBJECT
64 
65  public:
66  spoton_neighbor_tcp_socket(QObject *parent = 0):QSslSocket(parent)
67  {
68  }
69 
70  void setLocalAddress(const QHostAddress &address)
71  {
72  QSslSocket::setLocalAddress(address);
73  }
74 };
75 
76 class spoton_neighbor_udp_socket: public QUdpSocket
77 {
78  Q_OBJECT
79 
80  public:
81  spoton_neighbor_udp_socket(QObject *parent = 0):QUdpSocket(parent)
82  {
83  m_multicastSocket = 0;
84  }
85 
86  void initializeMulticast(const QHostAddress &address,
87  const quint16 port,
88  const QString &socketOptions)
89  {
90  if(address.protocol() == QAbstractSocket::IPv4Protocol)
91  {
92  quint32 a = address.toIPv4Address();
93 
94  if(!((a & 0xf0000000) == 0xe0000000))
95  return;
96  }
97  else if(address.protocol() == QAbstractSocket::IPv6Protocol)
98  {
99  Q_IPV6ADDR a6 = address.toIPv6Address();
100 
101  if(a6.c[0] != 0xff)
102  return;
103  }
104  else
105  return;
106 
107  if(m_multicastSocket)
108  m_multicastSocket->deleteLater();
109 
110  m_multicastSocket = new QUdpSocket(this);
111 
112  if(!m_multicastSocket->bind(address,
113  port,
114  QUdpSocket::ReuseAddressHint |
115  QUdpSocket::ShareAddress))
116  {
117  m_multicastSocket->deleteLater();
118  spoton_misc::logError
119  (QString("spoton_neighbor_udp_socket::initializeMulticast(): "
120  "bind() failure for %1:%2.").
121  arg(address.toString()).arg(port));
122  return;
123  }
124 
125  spoton_socket_options::setSocketOptions
126  (socketOptions,
127  "udp",
128  static_cast<qint64> (m_multicastSocket->socketDescriptor()),
129  0);
130 #if QT_VERSION >= 0x040806
131  if(!m_multicastSocket->joinMulticastGroup(address))
132  {
133  m_multicastSocket->deleteLater();
134  spoton_misc::logError
135  (QString("spoton_neighbor_udp_socket::initializeMulticast(): "
136  "joinMulticastGroup() failure for %1:%2.").
137  arg(address.toString()).arg(port));
138  }
139  else
140  m_multicastSocket->setSocketOption
141  (QAbstractSocket::MulticastLoopbackOption, 1);
142 #else
143  if(!spoton_misc::joinMulticastGroup(address,
144  1, // Enable loopback.
145  m_multicastSocket->socketDescriptor(),
146  port))
147  m_multicastSocket->deleteLater();
148 #endif
149  }
150 
151  QPointer<QUdpSocket> multicastSocket(void) const
152  {
153  return m_multicastSocket;
154  }
155 
156  void setLocalAddress(const QHostAddress &address)
157  {
158  QUdpSocket::setLocalAddress(address);
159  }
160 
161  void setLocalPort(quint16 port)
162  {
163  QUdpSocket::setLocalPort(port);
164  }
165 
166  void setPeerAddress(const QHostAddress &address)
167  {
168  QUdpSocket::setPeerAddress(address);
169  }
170 
171  void setPeerPort(quint16 port)
172  {
173  QUdpSocket::setPeerPort(port);
174  }
175 
176  private:
177  QPointer<QUdpSocket> m_multicastSocket;
178 };
179 
180 class spoton_neighbor: public QThread
181 {
182  Q_OBJECT
183 
184  public:
185  spoton_neighbor(void)
186  {
187  }
188 
189  spoton_neighbor(const QNetworkProxy &proxy,
190  const QString &ipAddress,
191  const QString &port,
192  const QString &scopeId,
193  const qint64 id,
194  const bool userDefined,
195  const int keySize,
196  const qint64 maximumBufferSize,
197  const qint64 maximumContentLength,
198  const QString &echoMode,
199  const QByteArray &peerCertificate,
200  const bool allowExceptions,
201  const QString &protocol,
202  const bool requireSsl,
203  const QByteArray &accountName,
204  const QByteArray &accountPassword,
205  const QString &transport,
206  const QString &orientation,
207  const QString &motd,
208  const QString &statusControl,
209  const QString &sslControlString,
210  const Priority priority,
211  const int laneWidth,
212  const int passthrough,
213  const int waitforbyteswritten_msecs,
214  const QByteArray &privateApplicationCredentials,
215  const int silenceTime,
216  const QString &socketOptions,
217  QObject *parent);
218 
219  /*
220  ** We're a server. Let's represent a client connection.
221  */
222 
224 #if QT_VERSION < 0x050000
225  const int socketDescriptor,
226 #else
227  const qintptr socketDescriptor,
228 #endif
229  const QByteArray &certificate,
230  const QByteArray &privateKey,
231  const QString &echoMode,
232  const bool useAccounts,
233  const qint64 listenerOid,
234  const qint64 maximumBufferSize,
235  const qint64 maximumContentLength,
236  const QString &transport,
237  const QString &ipAddress,
238  const QString &port,
239  const QString &localIpAddress,
240  const QString &localPort,
241  const QString &orientation,
242  const QString &motd,
243  const QString &sslControlString,
244  const Priority priority,
245  const int laneWidth,
246  const int passthrough,
247  const int sourceOfRandomness,
248  const QByteArray &privateApplicationCredentials,
249 #if QT_VERSION >= 0x050501 && defined(SPOTON_BLUETOOTH_ENABLED)
250  QBluetoothSocket *socket,
251 #endif
252  QObject *parent);
253  ~spoton_neighbor();
254  QAbstractSocket::SocketState state(void) const;
255  QString localAddress(void) const;
256  QString peerAddress(void) const;
257 
258  QString scopeId(void) const
259  {
260  return m_scopeId;
261  }
262 
263  QString transport(void) const;
264  QUuid receivedUuid(void);
265  bool isEncrypted(void) const;
266  bool writeMessage0060(const QByteArray &data);
267  qint64 id(void) const;
268  qint64 write(const char *data, qint64 size);
269  quint16 peerPort(void) const;
270  void abort(void);
271  void close(void);
272  void processData(void);
273  void setId(const qint64 id);
274 
275  private:
276  QAtomicInt m_abort;
277  QAtomicInt m_accountAuthenticated;
278  QAtomicInt m_kernelInterfaces;
279  QAtomicInt m_passthrough;
280  QAtomicInt m_useAccounts;
281  QAtomicInt m_waitforbyteswritten_msecs;
282  QByteArray m_accountName;
283  QByteArray m_accountPassword;
284  QByteArray m_accountClientSentSalt;
285  QByteArray m_data;
286  QByteArray m_privateApplicationCredentials;
287  QDateTime m_lastReadTime;
288  QDateTime m_startTime;
289  QList<QFuture<void> > m_privateApplicationFutures;
290  QList<QPair<QByteArray, QByteArray> > m_learnedAdaptiveEchoPairs;
291  QMap<quint64, QByteArray> m_privateApplicationMap;
292  QMutex m_privateApplicationMutex;
293  QPair<QByteArray, QByteArray> m_adaptiveEchoPair;
294  QPair<quint64, quint64> m_privateApplicationSequences;
295 #if QT_VERSION >= 0x050501 && defined(SPOTON_BLUETOOTH_ENABLED)
296  QPointer<QBluetoothSocket> m_bluetoothSocket;
297 #else
298  QPointer<QObject> m_bluetoothSocket;
299 #endif
300 #if (QT_VERSION >= QT_VERSION_CHECK(5, 12, 0))
301  QPointer<QDtls> m_dtls;
302 #endif
303  QReadWriteLock m_accountClientSentSaltMutex;
304  QReadWriteLock m_accountNameMutex;
305  QReadWriteLock m_accountPasswordMutex;
306  QReadWriteLock m_bytesDiscardedOnWriteMutex;
307  QReadWriteLock m_bytesWrittenMutex;
308  QReadWriteLock m_dataMutex;
309  QReadWriteLock m_echoModeMutex;
310  QReadWriteLock m_learnedAdaptiveEchoPairsMutex;
311  QReadWriteLock m_maximumBufferSizeMutex;
312  QReadWriteLock m_maximumContentLengthMutex;
313  QReadWriteLock m_receivedUuidMutex;
314  QSslCertificate m_peerCertificate;
315 #if (QT_VERSION >= QT_VERSION_CHECK(5, 12, 0))
316  QSslConfiguration m_udpSslConfiguration;
317 #endif
318  QString m_address;
319  QString m_echoMode;
320  QString m_ipAddress;
321  QString m_motd;
322  QString m_orientation;
323  QString m_protocol;
324  QString m_scopeId;
325  QString m_socketOptions;
326  QString m_sslControlString;
327  QString m_statusControl;
328  QString m_transport;
329  QTimer m_accountTimer;
330  QTimer m_authenticationTimer;
331  QTimer m_externalAddressDiscovererTimer;
332  QTimer m_keepAliveTimer;
333  QTimer m_lifetime;
334  QTimer m_timer;
335  QUuid m_receivedUuid;
336  bool m_allowExceptions;
337  bool m_isUserDefined;
338  bool m_requireSsl;
339  bool m_useSsl;
340  int m_keySize;
341  int m_laneWidth;
342  int m_silenceTime;
343  int m_sourceOfRandomness;
344  qint64 m_id;
345  qint64 m_listenerOid;
346  qint64 m_maximumBufferSize;
347  qint64 m_maximumContentLength;
348  quint16 m_port;
349  quint64 m_bytesDiscardedOnWrite;
350  quint64 m_bytesRead;
351  quint64 m_bytesWritten;
352  spoton_external_address *m_externalAddress;
353  spoton_neighbor_tcp_socket *m_tcpSocket;
354  spoton_neighbor_udp_socket *m_udpSocket;
355  spoton_sctp_socket *m_sctpSocket;
356  QString findMessageType
357  (const QByteArray &data,
358  QList<QByteArray> &symmetricKeys,
359  QPair<QByteArray, QByteArray> &discoveredAdaptiveEchoPair);
360  bool readyToWrite(void);
361  void addToBytesWritten(const qint64 bytesWritten);
362  void bundlePrivateApplicationData
363  (const QByteArray &data,
364  const QByteArray &privateApplicationCredentials,
365  const qint64 id,
366  const quint64 sequence);
367  void parsePrivateApplicationData
368  (const QByteArray &data,
369  const QByteArray &privateApplicationCredentials,
370  const qint64 maximumContentLength);
371 #if (QT_VERSION >= QT_VERSION_CHECK(5, 12, 0))
372  void prepareDtls(void);
373 #endif
374  void process0000(int length, const QByteArray &data,
375  const QList<QByteArray> &symmetricKeys);
376  void process0000a(int length, const QByteArray &data,
377  const QString &messageType);
378  void process0000b(int length, const QByteArray &data,
379  const QList<QByteArray> &symmetricKeys);
380  void process0000d(int length, const QByteArray &data,
381  const QList<QByteArray> &symmetricKeys);
382  void process0001a(int length, const QByteArray &data);
383  void process0001b(int length, const QByteArray &data,
384  const QList<QByteArray> &symmetricKeys);
385  void process0001c(int length, const QByteArray &data,
386  const QList<QByteArray> &symmetricKeys);
387  void process0002a(int length, const QByteArray &data,
388  const QPair<QByteArray, QByteArray> &adaptiveEchoPair);
389  void process0002b(int length, const QByteArray &data,
390  const QList<QByteArray> &symmetricKeys,
391  const QPair<QByteArray, QByteArray> &adaptiveEchoPair);
392  void process0011(int length, const QByteArray &data);
393  void process0012(int length, const QByteArray &data);
394  void process0013(int length, const QByteArray &data,
395  const QList<QByteArray> &symmetricKeys);
396  void process0014(int length, const QByteArray &data);
397  void process0030(int length, const QByteArray &data);
398  void process0040a(int length, const QByteArray &data,
399  const QList<QByteArray> &symmetricKeys);
400  void process0040b(int length, const QByteArray &data,
401  const QList<QByteArray> &symmetricKeys);
402  void process0050(int length, const QByteArray &data);
403  void process0051(int length, const QByteArray &data);
404  void process0065(int length, const QByteArray &data);
405  void process0070(int length, const QByteArray &data);
406  void process0080(int length, const QByteArray &data,
407  const QList<QByteArray> &symmetricKeys);
408  void process0090(int length, const QByteArray &data,
409  const QList<QByteArray> &symmetricKeys);
410  void process0091a(int length, const QByteArray &data,
411  const QList<QByteArray> &symmetricKeys);
412  void process0091b(int length, const QByteArray &data,
413  const QList<QByteArray> &symmetricKeys);
414  void process0092(int length, const QByteArray &data,
415  const QList<QByteArray> &symmetricKeys);
416  void process0095a(int length, const QByteArray &data);
417  void process0095b(int length, const QByteArray &data);
418  void recordCertificateOrAbort(void);
419  void run(void);
420  void saveExternalAddress(const QHostAddress &address,
421  const QSqlDatabase &db);
422  void saveGemini(const QByteArray &publicKeyHash,
423  const QByteArray &gemini,
424  const QByteArray &geminiHashKey,
425  const QByteArray &timestamp,
426  const QByteArray &signature,
427  const QString &messageType);
428  void saveParticipantStatus(const QByteArray &publicKeyHash);
429  void saveParticipantStatus(const QByteArray &name,
430  const QByteArray &publicKeyHash);
431  void saveParticipantStatus(const QByteArray &name,
432  const QByteArray &publicKeyHash,
433  const QByteArray &status,
434  const QByteArray &timestamp);
435  void savePublicKey(const QByteArray &keyType,
436  const QByteArray &name,
437  const QByteArray &publicKey,
438  const QByteArray &signature,
439  const QByteArray &sPublicKey,
440  const QByteArray &sSignature,
441  const qint64 neighbor_oid,
442  const bool ignore_key_permissions,
443  const bool signatures_required,
444  const QString &messageType);
445  void saveStatistics(const QSqlDatabase &db);
446  void saveStatus(const QSqlDatabase &db, const QString &status);
447  void saveStatus(const QString &status);
448  void saveUrlsToShared(const QList<QByteArray> &urls);
449  void storeLetter(const QByteArray &symmetricKey,
450  const QByteArray &symmetricKeyAlgorithm,
451  const QByteArray &hashKey,
452  const QByteArray &hashKeyAlgorithm,
453  const QByteArray &senderPublicKeyHash,
454  const QByteArray &name,
455  const QByteArray &subject,
456  const QByteArray &message,
457  const QByteArray &date,
458  const QByteArray &attachmentData,
459  const QByteArray &signature,
460  const bool goldbugUsed);
461  void storeLetter(const QList<QByteArray> &list,
462  const QByteArray &recipientHash);
463 
464  private slots:
465  void slotAccountAuthenticated(const QByteArray &clientSalt,
466  const QByteArray &name,
467  const QByteArray &password);
468  void slotAuthenticationTimerTimeout(void);
469  void slotCallParticipant(const QByteArray &data,
470  const QString &messageType);
471  void slotConnected(void);
472  void slotDisconnected(void);
473  void slotDiscoverExternalAddress(void);
474  void slotEchoKeyShare(const QByteArrayList &list);
475  void slotEncrypted(void);
476  void slotError(QAbstractSocket::SocketError error);
477 #if QT_VERSION >= 0x050501 && defined(SPOTON_BLUETOOTH_ENABLED)
478  void slotError(QBluetoothSocket::SocketError error);
479 #endif
480  void slotError(const QString &method,
481  const spoton_sctp_socket::SocketError error);
482  void slotExternalAddressDiscovered(const QHostAddress &address);
483 #if (QT_VERSION >= QT_VERSION_CHECK(5, 12, 0))
484  void slotHandshakeTimeout(void);
485 #else
486  void slotHandshakeTimeout(void);
487 #endif
488  void slotHostFound(const QHostInfo &hostInfo);
489  void slotLifetimeExpired(void);
490  void slotModeChanged(QSslSocket::SslMode mode);
491  void slotNewDatagram(const QByteArray &datagram,
492  const QHostAddress &address,
493  const quint16 port);
494  void slotPeerVerifyError(const QSslError &error);
495  void slotProxyAuthenticationRequired(const QNetworkProxy &proxy,
496  QAuthenticator *authenticator);
497 #if QT_VERSION >= 0x050501 && defined(SPOTON_BLUETOOTH_ENABLED)
498  void slotPublicizeListenerPlaintext(const QBluetoothAddress &address,
499  const quint16 port,
500  const QString &orientation);
501 #endif
502  void slotPublicizeListenerPlaintext(const QByteArray &data,
503  const qint64 id);
504  void slotPublicizeListenerPlaintext(const QHostAddress &address,
505  const quint16 port,
506  const QString &transport,
507  const QString &orientation);
508  void slotReadyRead(void);
509  void slotResetKeepAlive(void);
510  void slotRetrieveMail(const QByteArrayList &list,
511  const QString &messageType);
512  void slotSMPMessageReceivedFromUI(const QByteArrayList &list);
513  void slotSendAccountInformation(void);
514  void slotSendAuthenticationRequest(void);
515  void slotSendBuzz(const QByteArray &data);
516  void slotSendCapabilities(void);
517  void slotSendForwardSecrecyPublicKey(const QByteArray &data);
518  void slotSendForwardSecrecySessionKeys(const QByteArray &data);
519  void slotSendMOTD(void);
520  void slotSendMail(const QPairByteArrayInt64List &list,
521  const QString &messageType);
522  void slotSendMailFromPostOffice
523  (const QByteArray &data,
524  const QPairByteArrayByteArray &adaptiveEchoPair);
525  void slotSendMessage(const QByteArray &data,
526  const spoton_send::spoton_send_method sendMethod);
527  void slotSendStatus(const QByteArrayList &list);
528  void slotSslErrors(const QList<QSslError> &errors);
529  void slotStopTimer(QTimer *timer);
530  void slotTimeout(void);
531  void slotWrite(const QByteArray &data, const qint64 id,
532  const QPairByteArrayByteArray &adaptiveEchoPair);
533  void slotWriteParsedApplicationData(const QByteArray &data);
534  void slotWriteURLs(const QByteArray &data);
535 
536  public slots:
537  void deleteLater(void);
538  void slotSharePublicKey(const QByteArray &keyType,
539  const QByteArray &name,
540  const QByteArray &publicKey,
541  const QByteArray &signature,
542  const QByteArray &sPublicKey,
543  const QByteArray &sSignature);
544 
545  signals:
546  void accountAuthenticated(const QByteArray &clientSalt,
547  const QByteArray &name,
548  const QByteArray &password);
549  void authenticationRequested(const QString &peerInformation);
550 #if QT_VERSION >= 0x050501 && defined(SPOTON_BLUETOOTH_ENABLED)
551  void bluetooth(const QBluetoothServiceInfo &serviceInfo);
552 #endif
553  void callParticipant(const QByteArray &publicKeyHash,
554  const QByteArray &gemini,
555  const QByteArray &geminiHashKey);
556  void disconnected(void);
557  void forwardSecrecyRequest(const QByteArrayList &list);
558  void newData(void);
559  void newEMailArrived(void);
560  void notification(const QString &text);
561  void publicizeListenerPlaintext(const QByteArray &data, const qint64 id);
562  void receivedBuzzMessage(const QByteArrayList &list,
563  const QByteArrayList &symmetricKeys);
564  void receivedChatMessage(const QByteArray &data);
565  void receivedMessage
566  (const QByteArray &data, const qint64 id,
567  const QPairByteArrayByteArray &adaptiveEchoPair);
568  void receivedPublicKey(const QByteArray &name, const QByteArray publicKey);
569  void resetKeepAlive(void);
570  void retrieveMail(const QByteArray &data,
571  const QByteArray &publicKeyHash,
572  const QByteArray &timestamp,
573  const QByteArray &signature,
574  const QPairByteArrayByteArray &adaptiveEchoPair);
575  void saveForwardSecrecySessionKeys(const QByteArrayList &list);
576  void scrambleRequest(void);
577  void sharePublicKey(const QByteArray &keyType,
578  const QByteArray &name,
579  const QByteArray &publicKey,
580  const QByteArray &signature,
581  const QByteArray &sPublicKey,
582  const QByteArray &sSignature);
583  void smpMessage(const QByteArrayList &list);
584  void statusMessageReceived(const QByteArray &publicKeyHash,
585  const QString &status);
586  void stopTimer(QTimer *timer);
587  void writeParsedApplicationData(const QByteArray &data);
588 };
589 
590 class spoton_neighbor_worker: public QObject
591 {
592  Q_OBJECT
593 
594  public:
595  spoton_neighbor_worker(spoton_neighbor *neighbor):QObject(0)
596  {
597  m_neighbor = neighbor;
598  }
599 
601  {
602  }
603 
604  private:
605  QPointer<spoton_neighbor> m_neighbor;
606 
607  private slots:
608  void slotNewData(void)
609  {
610  if(m_neighbor)
611  m_neighbor->processData();
612  }
613 };
614 #endif
Definition: spot-on-neighbor.h:180
Definition: spot-on-neighbor.h:76
Definition: spot-on-neighbor.h:590
Definition: spot-on-external-address.h:35
Definition: spot-on-neighbor.h:61
Definition: spot-on-sctp-socket.h:36